Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/core/execution/WarshipExecution.ts`:
- Around line 149-151: The split-heal math currently produces fractional values
(healingPool / dockedShips) but UnitImpl.modifyHealth stores health as an
integer causing silent truncation; update the healing path so fractional HP are
preserved by making UnitImpl.modifyHealth accept and store a floating-point
number (change its parameter/type and the internal health field from integer to
number) and ensure any serialization/display layers (e.g., health getters or
network payloads) round for presentation only; update references to modifyHealth
in WarshipExecution and any other callers to pass the numeric (float) value
unchanged and add/adjust tests to cover fractional heals.
- Around line 133-152: The healing logic in WarshipExecution uses a hard-coded
docking radius (5) and counts all friendly warships, which differs from
isPortFullOfHealing() that uses warshipPortHealingRadius() and considers
retreating ships; update WarshipExecution (and the other occurrences around the
noted ranges) to compute the same docked-ship set used by isPortFullOfHealing():
read docking radius from mg.config().warshipPortHealingRadius(), filter
owner.units(UnitType.Warship) by the same retreating/retreat-state predicate
used in isPortFullOfHealing(), and use that single set both to compute
dockedShips (capacity) and to divide the healingPool (activeHealing); ensure you
replace the hard-coded 5 and any differing membership tests so healing and
port-full checks operate on the identical ship set.

In `@tests/Warship.test.ts`:
- Around line 340-370: The test never fills the port slot because only warship1
attempts to retreat; create a second warship (e.g., warship2 via
player1.buildUnit(UnitType.Warship, ...)), start its WarshipExecution (new
WarshipExecution(warship2) and game.addExecution(exec2)), damage it
(warship2.modifyHealth(...)) and advance ticks until exec2.isDocked() is true so
the port slot is occupied, then damage warship1 and run the existing loop to
verify warship1 waits and exec1.isDocked() becomes true only after the slot
frees; reference WarshipExecution, exec1, exec2, warship1.modifyHealth and
warship2.modifyHealth to locate changes.
- Around line 203-224: The test currently asserts warship.targetUnit() after a
single tick which is unstable; instead, make the assertion on a stable
first-engagement effect: configure warshipShellAttackRate to ensure an attack
occurs (as in the setup), run ticks until the warship's attack resolves (use
game.executeNextTick() in a loop or until a combat event), and then assert that
the TransportShip's hit points or alive state changed (or that the TransportShip
took damage) rather than checking warship.targetUnit(); reference the
WarshipExecution instance, the warship variable, and the TransportShip unit
created to locate where to change the assertion.

---

Outside diff comments:
In `@src/core/game/UnitImpl.ts`:
- Around line 223-230: The modifyHealth method currently always calls
this.mg.addUpdate(this.toUpdate()) even when the clamped health equals the
previous value; change modifyHealth (in UnitImpl.modifyHealth) to capture the
previous health (e.g., prev = this._health), compute the new clamped value as
now, assign only after comparison, and only call
this.mg.addUpdate(this.toUpdate()) when now !== prev OR when prev !== 0n && now
=== 0n (i.e., crossing to death) so healWarship ticks on full-health ships won't
emit no-op updates; keep the existing use of withinInt, toInt and
this.info().maxHealth when computing the clamped value.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/core/execution/WarshipExecution.ts`:
- Around line 252-254: The current distance checks use a single global
warshipPortHealingRadius() so all ports share the same docking radius; change
the logic to compute a level-aware docking radius using the port's level (e.g.,
call a new config accessor or apply a scaling based on port.level()) and then
compute dockingRadiusSq from that value before comparing with distToPort; update
both occurrences where dockingRadius/dockingRadiusSq is used (the block
computing dockingRadius/dockingRadiusSq and the similar block later) so
port.level() influences docking range rather than only capacity.
- Around line 86-107: The current flow sets the target with
warship.setTargetUnit(this.findTargetUnit()) then calls patrol() which can
change position and invalidate range for subsequent shoots; to fix, either call
this.shootTarget() (or perform range checks) before calling this.patrol(), or
recompute the target after movement by calling
this.warship.setTargetUnit(this.findTargetUnit()) (and/or verify
this.warship.targetUnit() range inside shootTarget()) so shootTarget() always
uses a fresh, in-range target; update the logic around findTargetUnit, patrol,
warship.setTargetUnit, and shootTarget accordingly.
- Around line 66-72: The early return when this.docked is true must revalidate
the docked port before exiting: inside the WarshipExecution branch that checks
this.docked (around isFullyHealed()/cancelRepairRetreat()), call
refreshRetreatPortTile() (and/or applyActiveDockedHealing()) to confirm the
friendly port still exists/controls the tile; if the refresh indicates the port
is gone or no longer friendly, clear this.docked and call cancelRepairRetreat()
so execution can proceed normally; otherwise, keep the existing behavior (leave
docked true and return). Ensure you reference the WarshipExecution methods
refreshRetreatPortTile(), applyActiveDockedHealing(), isFullyHealed(), and
cancelRepairRetreat() when making the check and state change.
- Around line 194-205: The current fallback loop in WarshipExecution that picks
the closest port even when component filtering found no reachable ports must be
removed so unreachable ports aren't returned; update the helper (the method
containing the shown loop) to return undefined when no ports remain after
component-based reachability filtering instead of computing bestTile by
distance, and mirror this same change in findNearestAvailablePortTile() and the
other analogous helper later in the file so handleRepairRetreat() receives
undefined for unreachable ports and can cancel the retreat cleanly (do not
reintroduce a global nearest-port fallback).

---

Nitpick comments:
In `@tests/Warship.test.ts`:
- Around line 361-411: The current test only asserts the initial waiting state
but doesn't verify that exec2 actually retries and takes the port slot after
exec1 undocks; update the test (the "Warship waits at port when capacity is
full" case) to continue advancing ticks after detecting exec1.isDocked() becomes
false (or after exec1 heals/undocks) and then wait until exec2.isDocked()
becomes true (and exec2.retreating() is false), asserting that exec2 eventually
docks within a reasonable tick limit; use the existing WarshipExecution
instances (exec1, exec2) and units (warship1, warship2) and the methods
isDocked() and retreating() to implement this additional check.

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@src/core/execution/WarshipExecution.ts`:
- Around line 399-430: Consolidate duplicated port-iteration logic in
findNearestAvailablePort() and findNearestAvailablePortTile() by extracting a
single helper (e.g., findNearestPortTileWithOptions or findNearestPortTile) that
accepts an option/flag like excludeSelf:boolean (or a predicate) and reuses the
same water-component filtering and distance calculation; update both original
methods to call the new helper with excludeSelf true/false as appropriate,
ensure the helper uses this.isPortFullOfHealing(port) conditioned on excludeSelf
when checking capacity, and keep return type TileRef | undefined unchanged so
callers and tests continue to work.

In `@tests/Warship.test.ts`:
- Around line 470-475: The test is reaching into private internals by casting to
executionInternals to access findTargetUnit and pathfinder (and
PathStatus/transport), which is fragile; refactor by exposing a test-friendly
interface or making those members protected so tests can depend on a stable
contract: define an interface (e.g., IExecutionTestHelpers) with findTargetUnit
and pathfinder.next signatures, update the class under test to implement or
expose that interface (or provide a protected accessor) and change the test to
cast to that interface instead of an ad-hoc unknown cast, ensuring compile-time
safety if findTargetUnit or pathfinder are renamed/refactored.